home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_12_11 / allison / pool.c < prev    next >
C/C++ Source or Header  |  1994-09-05  |  2KB  |  99 lines
  1. LISTING 31 - Generic pool manager implementation
  2. /* pool.c:  Generic memory pool manager */
  3. #include <assert.h>
  4. #include <stdlib.h>
  5. #include "pool.h"
  6.  
  7. #define MAX_CHUNKS 64
  8.  
  9. typedef struct Pool
  10. {
  11.      size_t elem_size;
  12.      size_t extent;
  13.      char *free_ptr;
  14.      void *chunks[MAX_CHUNKS];
  15.      size_t nchunks;
  16. } Pool;
  17.  
  18. typedef struct Overlay
  19. {
  20.      void *next;
  21. } Overlay;
  22.  
  23. static void make_chunk(Pool *p, size_t nelems)
  24. {
  25.       int i;
  26.       char *free_ptr;
  27.       void *chunk;
  28.       Overlay *current;
  29.  
  30.       /* Allocate chunk */
  31.       assert(p);
  32.       chunk = calloc(nelems,p->elem_size);
  33.       assert(chunk);
  34.       free_ptr = (char *) chunk;
  35.  
  36.       /* Link elements together */
  37.       for (i = 0; i < nelems-1; ++i)
  38.       {
  39.             current = (Overlay *) free_ptr;
  40.             current->next = free_ptr += p->elem_size;
  41.       }
  42.       current = (Overlay *) free_ptr;
  43.       current->next = NULL;   /* Redundant */
  44.  
  45.       /* Update pool state */
  46.       p->free_ptr = (char *) chunk;
  47.       p->chunks[p->nchunks++] = chunk;
  48. }
  49.  
  50. Pool *pool_create(size_t elem_size, size_t init_alloc,
  51.                       size_t extent)
  52. {
  53.       /* Allocate pool */
  54.       Pool *p = malloc(sizeof(Pool));
  55.       assert(p);
  56.       p->elem_size = elem_size;
  57.       p->extent = extent;
  58.       p->nchunks = 0;
  59.  
  60.       /* Allocate first chunk */
  61.       make_chunk(p,init_alloc);
  62.       return p;
  63. }
  64.  
  65. void *pool_get_elem(Pool *p)
  66. {
  67.       void *new_node;
  68.  
  69.       assert(p);
  70.       if (p->free_ptr == NULL && p->nchunks < MAX_CHUNKS)
  71.             /* Add a new chunk to pool */
  72.             make_chunk(p,p->extent);
  73.  
  74.       assert(p->free_ptr);
  75.       new_node = p->free_ptr;
  76.       p->free_ptr = ((Overlay *) p->free_ptr)->next;
  77.       return new_node;
  78. }
  79.  
  80. void pool_release_elem(Pool *p, void *elem)
  81. {
  82.       /* Prepend elem to free list */
  83.       Overlay *optr = elem;
  84.  
  85.       assert(p);
  86.       optr->next = p->free_ptr;
  87.       p->free_ptr = (char *) elem;
  88. }
  89.  
  90. void pool_free(Pool *p)
  91. {
  92.       int i;
  93.  
  94.       assert(p);
  95.       for (i = 0; i < p->nchunks; ++i)
  96.           free(p->chunks[i]);
  97.       free(p);
  98. }
  99.